home *** CD-ROM | disk | FTP | other *** search
/ Gamers Delight 2 / Gamers Delight 2.iso / Aminet / game / demo / GDS_VIEWER.lha / ar_viewer.c < prev    next >
C/C++ Source or Header  |  1994-03-13  |  15KB  |  537 lines
  1. /*******************************************************************************************
  2.  
  3. This quick & dirty picture viewer was put together for Amiga Report online magazine, a not-
  4. for-profit organization.  It makes use of the GameSmith ILBM picture loader.  For more
  5. information about the GameSmith Development System, contact:
  6.  
  7.     Bithead Technologies
  8.     8085 North Raleigh Place
  9.     Westminster, Colorado 80030-4316
  10.     USA
  11.     (303) 427-9521
  12.  
  13. This source code is hereby placed in the public domain.
  14.  
  15. USAGE: ar_viewer (filename) [X offset] [Y offset] [Workbench]
  16.  
  17. *******************************************************************************************/
  18.  
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21.  
  22. #include <exec/types.h>
  23. #include <intuition/intuition.h>
  24. #include <intuition/intuitionbase.h>
  25. #include <graphics/gfx.h>
  26. #include <clib/exec_protos.h>
  27. #include <clib/intuition_protos.h>
  28. #include <clib/graphics_protos.h>
  29. #include <pragmas/exec_sysbase_pragmas.h>
  30. #include <pragmas/intuition_pragmas.h>
  31. #include <pragmas/graphics_pragmas.h>
  32.  
  33. #include "GameSmith:include/libraries/libptrs.h"
  34. #include "GameSmith:GameSmith.h"
  35.  
  36. #define FONT_WIDTH    8
  37. #define FONT_HEIGHT    8
  38.  
  39. #define CUSTOM_FLAGS    (BORDERLESS|SUPER_BITMAP|ACTIVATE|NOCAREREFRESH|GIMMEZEROZERO|WINDOWCLOSE)
  40. #define WB_FLAGS        (SUPER_BITMAP|ACTIVATE|WINDOWSIZING|WINDOWDEPTH|WINDOWCLOSE|WINDOWDRAG|GIMMEZEROZERO|NOCAREREFRESH)
  41.  
  42. #define CUSTOM_SCREEN    0
  43. #define WB_SCREEN            1
  44.  
  45. /* ----------------------------------------------------------------------- */
  46. /* Function prototypes:                                                    */
  47.  
  48. int get_wb_info(void);
  49. int load_image(char *);
  50. int display_image(char *,int);
  51. int display_image_window(char *);
  52. int display_image_screen(char *);
  53.  
  54. /* ----------------------------------------------------------------------- */
  55.  
  56. int left,right,top,bottom,barheight,width,height,depth;
  57. unsigned long color[256];            /* color table */
  58.  
  59. char screen_title[]="GameSmith® IFF ILBM Loader";
  60.  
  61. char topaz8_text[]="topaz.font";
  62.  
  63. struct TextAttr topaz8 =
  64.     {
  65.     topaz8_text,                        /* Addr of ASCIIZ string containing font name */
  66.     8,                                        /* font YSize (height) */
  67.     FS_NORMAL,                            /* style flags */
  68.     FPF_DESIGNED|FPF_ROMFONT        /* flags */
  69.     };
  70.  
  71. unsigned short pens[] = {0xffff};    /* needed for new (3d) look */
  72.  
  73. struct TagItem tags[] = {
  74.     {
  75.     SA_Pens,
  76.     (unsigned long)pens
  77.     },
  78.     {
  79.     SA_Width,
  80.     STDSCREENWIDTH
  81.     },
  82.     {
  83.     SA_Height,
  84.     STDSCREENHEIGHT
  85.     },
  86.     {
  87.     SA_Depth,
  88.     0L
  89.     },
  90.     {
  91.     SA_AutoScroll,
  92.     1L
  93.     },
  94.     {
  95.     SA_Type,
  96.     CUSTOMSCREEN
  97.     },
  98.     {
  99.     SA_Quiet,
  100.     1L
  101.     },
  102.     {
  103.     SA_Overscan,
  104.     OSCAN_TEXT
  105.     },
  106.     {
  107.     TAG_DONE,
  108.     0L
  109.     }
  110.     };
  111.  
  112. struct ExtNewScreen newscreen =
  113.     {
  114.     0,0,                                    /* left & top edges */
  115.     0,0,0,                                /* width, height, & depth (filled) */
  116.     1,2,                                    /* detail & block pens */
  117.     0,                                        /* view modes (filled) */
  118.     CUSTOMSCREEN|SCREENQUIET|AUTOSCROLL|
  119.     NS_EXTENDED,                        /* type */
  120.     &topaz8,                                /* text attribute for font */
  121.     NULL,                                    /* screen title */
  122.     NULL,                                    /* ptr to gadgets */
  123.     NULL,                                    /* ptr to bitmap */
  124.     tags                                    /* addr of screen tags for V6 and later */
  125.     };
  126.  
  127. char custom_text[]="Custom Screen";
  128. char wb_text[]="WorkBench Window";
  129. char quit_text[]="Quit";
  130.  
  131. struct IntuiText item1b_it =
  132.     {
  133.     1,0,                                /* Front & Back pens (color reg #) */
  134.     JAM1,                                /* Draw mode */
  135.     0,1,                                /* left & top edge offsets */
  136.     &topaz8,                            /* ptr to font desc. (ROM font) */
  137.     quit_text,                        /* addr of actual text string */
  138.     NULL                                /* ptr to next intuitext struct */
  139.     };
  140.  
  141. struct MenuItem item1b = 
  142.     {
  143.     NULL,                                /* ptr to next menu item */
  144.     0,                                    /* left edge */
  145.     FONT_HEIGHT+2,                    /* top edge */
  146.     17*FONT_WIDTH,                    /* width (# chars * width of font) */
  147.     FONT_HEIGHT+2,                    /* height */
  148.     ITEMTEXT|
  149.     ITEMENABLED|HIGHCOMP,        /* flags */
  150.     0,                                    /* mutual exclusion indicator (none) */
  151.     (APTR)&item1b_it,                /* ptr to item fill */
  152.     NULL,                                /* select fill (don't change, just highlight) */
  153.     0,                                    /* command, or hotkey */
  154.     NULL,                                /* ptr to 1st subitem */
  155.     NULL                                /* ptr to next selected item (system filled) */
  156.     };
  157.  
  158. struct IntuiText item1a_it =
  159.     {
  160.     1,0,                                /* Front & Back pens (color reg #) */
  161.     JAM1,                                /* Draw mode */
  162.     0,1,                                /* left & top edge offsets */
  163.     &topaz8,                            /* ptr to font desc. (ROM font) */
  164.     custom_text,                    /* addr of actual text string */
  165.     NULL                                /* ptr to next intuitext struct */
  166.     };
  167.  
  168. struct MenuItem item1a = 
  169.     {
  170.     &item1b,                            /* ptr to next menu item */
  171.     0,                                    /* left edge */
  172.     0,                                    /* top edge */
  173.     17*FONT_WIDTH,                    /* width (# chars * width of font) */
  174.     FONT_HEIGHT+2,                    /* height */
  175.     ITEMTEXT|
  176.     ITEMENABLED|HIGHCOMP,        /* flags */
  177.     0,                                    /* mutual exclusion indicator (none) */
  178.     (APTR)&item1a_it,                /* ptr to item fill */
  179.     NULL,                                /* select fill (don't change, just highlight) */
  180.     0,                                    /* command, or hotkey */
  181.     NULL,                                /* ptr to 1st subitem */
  182.     NULL                                /* ptr to next selected item (system filled) */
  183.     };
  184.  
  185. char menu1_text[]="Display";
  186.  
  187. struct Menu menu1 =
  188.     {
  189.     NULL,                        /* ptr to next menu struct */
  190.     0,0,                        /* left edge, top edge */
  191.     8*FONT_WIDTH,            /* width ((# chars + 1) * width of font) */
  192.     FONT_HEIGHT,            /* height (ignored by intuition) */
  193.     MENUENABLED,            /* flags */
  194.     menu1_text,                /* ptr to ASCIIZ name string */
  195.     &item1a                    /* ptr to 1st menu item */
  196.     };
  197.  
  198. BitMapHeader bmh;
  199.  
  200. struct loadILBM_struct loadimg = 
  201.     {
  202.     NULL,                    /* ptr to picture name string */
  203.     NULL,                    /* ptr to 1st bitmap */
  204.     NULL,                    /* ptr to 2nd bitmap (if any) */
  205.     color,                /* ptr to color table array */
  206.     256,                    /* # colors in color table */
  207.     NULL,                    /* height of image in pixels (filled by load call) */
  208.     NULL,                    /* width of image in pixels (filled) */
  209.     NULL,                    /* x display offset (filled) */
  210.     NULL,                    /* y display offset (filled) */
  211.     NULL,                    /* pic mode (filled) */
  212.     0,                        /* x load offset (from left) in bytes */
  213.     0,                        /* y load offset (from top) in rows */
  214.     ILBM_ALLOC1|ILBM_COLOR,    /* flags (alloc 1 bitmap, fill color table) */
  215.     0xff,                    /* bitplane fill mask */
  216.     0xff,                    /* bitplane load mask */
  217.     &bmh                    /* address of BitMapHeader to fill (optional) */
  218.     };
  219.  
  220. struct NewWindow pic_win=
  221.     {
  222.     0,0,0,0,                /* left edge, top edge, width, height */
  223.     1,2,                    /* detail & block pens */
  224.     CLOSEWINDOW|MENUPICK,    /* IDCMP flags */
  225.     WB_FLAGS,            /* window flags */
  226.     NULL,                    /* ptr to 1st gadget */
  227.     NULL,                    /* ptr to checkmark image */
  228.     NULL,                    /* window title */
  229.     NULL,                    /* ptr to screen */
  230.     NULL,                    /* ptr to bitmap to use for refresh */
  231.     30,30,0,0,            /* min width & height, max width & height */
  232.     WBENCHSCREEN        /* window type */
  233.     };
  234.  
  235. struct NewWindow pic_win2=
  236.     {
  237.     0,0,0,0,                /* left edge, top edge, width, height */
  238.     1,2,                    /* detail & block pens */
  239.     CLOSEWINDOW|MENUPICK,    /* IDCMP flags */
  240.     CUSTOM_FLAGS,        /* window flags */
  241.     NULL,                    /* ptr to 1st gadget */
  242.     NULL,                    /* ptr to checkmark image */
  243.     NULL,                    /* window title */
  244.     NULL,                    /* ptr to screen */
  245.     NULL,                    /* ptr to bitmap to use for refresh */
  246.     0,0,0,0,                /* min width & height, max width & height */
  247.     CUSTOMSCREEN        /* window type */
  248.     };
  249.  
  250. /***************************************************************************/
  251.  
  252. main(argc,argv)
  253. int argc;
  254. char *argv[];
  255.  
  256. {
  257.     int err;
  258.  
  259.     if (gs_open_libs(INTUITION|DOS|GRAPHICS,0))
  260.         exit(-99);                                /* open necessary Amiga libs */
  261.     if (argc < 2)                                /* check # command line arguements */
  262.         {
  263.         DisplayBeep(NULL);                    /* if error, flash the screen */
  264.         gs_close_libs();                        /* close Amiga libs */
  265.         exit(-98);                                /* 1st arg has to be name of file to display */
  266.         }
  267.     if (err=get_wb_info())                    /* get workbench size, depth, & window border info */
  268.         {
  269.         DisplayBeep(NULL);                    /* if error, flash the screen */
  270.         gs_close_libs();                        /* close Amiga libs */
  271.         exit(err);
  272.         }
  273.     if (argc >= 3)
  274.         pic_win.LeftEdge=atoi(argv[2]);    /* set left edge of window */
  275.     if (argc >= 4)
  276.         pic_win.TopEdge=atoi(argv[3]);    /* set top edge of window */
  277.     if (err=load_image(argv[1]))            /* load image into it's own bitmap */
  278.         {
  279.         DisplayBeep(NULL);                    /* if error, flash the screen */
  280.         gs_close_libs();                        /* close Amiga libs */
  281.         exit(err);
  282.         }
  283. /*    printf("\n%d x %d x %d\n",bmh.w,bmh.h,bmh.nPlanes); */    /* print dimensions */
  284.     if (argc >= 5)                                /* if 5th arguement */
  285.         err=display_image(argv[1],WB_SCREEN);    /* show on WB screen */
  286.     else
  287.         err=display_image(argv[1],CUSTOM_SCREEN);    /* else show on custom screen */
  288.     if (err)                                        /* if display error */
  289.         {
  290.         DisplayBeep(NULL);                    /* flash the screen */
  291.         gs_free_bitmap(loadimg.bitmap1);    /* free up bitmap we alloced by image load */
  292.         gs_close_libs();                        /* close Amiga libs */
  293.         exit(err);
  294.         }
  295.     gs_free_bitmap(loadimg.bitmap1);        /* free up bitmap we alloced by image load */
  296.     gs_close_libs();                            /* close Amiga libs */
  297.     exit(err);
  298. }
  299.  
  300. /***************************************************************************/
  301.  
  302. int get_wb_info()
  303.  
  304. {
  305.     struct Screen *s,screen13;        /* for polling WB attributes */
  306.  
  307.     if (IntuitionBase->LibNode.lib_Version >= 36)    /* if OS 2.0 or above */
  308.         {                                    /* get info about workbench screen */
  309.         if (!(s=LockPubScreen("Workbench")))
  310.             return(-97);
  311.         left=s->WBorLeft;
  312.         right=s->WBorRight;
  313.         top=s->WBorTop;
  314.         bottom=s->WBorBottom;
  315.         barheight=s->BarHeight;
  316.         width=s->Width;
  317.         height=s->Height;
  318.         depth=s->BitMap.Depth;
  319.         UnlockPubScreen(NULL,s);
  320.         }
  321.     else        /* else use old 1.3 method of polling WB attributes */
  322.         {
  323.         if (!GetScreenData(&screen13,sizeof(struct Screen),WBENCHSCREEN,NULL))
  324.             return(-97);
  325.         left=screen13.WBorLeft;
  326.         right=screen13.WBorRight;
  327.         top=screen13.WBorTop;
  328.         bottom=screen13.WBorBottom;
  329.         barheight=screen13.BarHeight;
  330.         width=screen13.Width;
  331.         height=screen13.Height;
  332.         depth=screen13.BitMap.Depth;
  333.         }
  334.     return(0);
  335. }
  336.  
  337. /***************************************************************************/
  338.  
  339. int load_image(file)
  340. char *file;
  341.  
  342. {
  343.     loadimg.file=file;
  344.     return(gs_loadILBM(&loadimg));        /* load the ILBM file */
  345. }
  346.  
  347. /***************************************************************************/
  348.  
  349. int display_image(file,target)
  350. char *file;
  351. int target;
  352.  
  353. {
  354.     int retcode=1;
  355.     
  356.     if (target == WB_SCREEN)
  357.         {
  358.         while (retcode > 0)
  359.             {
  360.             retcode=display_image_window(file);
  361.             if (retcode > 0)
  362.                 retcode=display_image_screen(file);
  363.             }
  364.         }
  365.     else
  366.         {
  367.         while (retcode > 0)
  368.             {
  369.             retcode=display_image_screen(file);
  370.             if (retcode > 0)
  371.                 retcode=display_image_window(file);
  372.             }
  373.         }
  374.     return(retcode);
  375. }
  376.  
  377. /***************************************************************************/
  378.  
  379. int display_image_window(file)
  380. char *file;
  381.  
  382. {
  383.     int done=0,retcode=0,right_edge,bottom_edge;
  384.     struct IntuiMessage *msg;
  385.     struct Window *win;
  386.     struct ExecBase *SysBase=*(struct ExecBase **)4;
  387.  
  388.                                                     /* now set window width & height */
  389.     pic_win.Width=bmh.w+left+right+14;
  390.     pic_win.Height=bmh.h+top+bottom+9;
  391.     pic_win.MaxWidth=pic_win.Width;        /* set maximum window width & height */
  392.     pic_win.MaxHeight=pic_win.Height;
  393.     pic_win.TopEdge+=barheight+1;
  394.     pic_win.BitMap=loadimg.bitmap1;        /* ptr to refresh bitmap */
  395.     if ((pic_win.Width+pic_win.LeftEdge) > width) /* make sure window fits in WB */
  396.         pic_win.Width=width-pic_win.LeftEdge;
  397.     if ((pic_win.Height+pic_win.TopEdge) > height)
  398.         pic_win.Height=height-pic_win.TopEdge;
  399.     pic_win.Title=file;                        /* title is name of file */
  400.     if (!(win=OpenWindow(&pic_win)))
  401.         return(-96);                            /* unable to open window */
  402.     if ((win->BorderRight != 18) || (win->BorderTop != 11) ||
  403.         (win->BorderLeft != 4) || (win->BorderBottom != 2))
  404.         {                                            /* make sure we got window borders correct */
  405.         right_edge=bmh.w+win->BorderLeft+win->BorderRight;
  406.         bottom_edge=bmh.h+win->BorderTop+win->BorderBottom;
  407.         WindowLimits(win,30,30,right_edge,bottom_edge);
  408.         SizeWindow(win,right_edge-win->Width,bottom_edge-win->Height);
  409.         }
  410.     SetWindowTitles(win,(UBYTE *)-1,screen_title);
  411.     item1a_it.IText=custom_text;
  412.     SetMenuStrip(win,&menu1);                /* tack on the menu */
  413.     while (!done)
  414.         {
  415.         WaitPort(win->UserPort);            /* wait for Intuition message */
  416.         msg=(struct IntuiMessage *)GetMsg(win->UserPort);
  417.         switch (msg->Class)
  418.             {
  419.             case CLOSEWINDOW:
  420.                 done=1;
  421.                 break;
  422.             case MENUPICK:
  423.                 switch (ITEMNUM(msg->Code))
  424.                     {
  425.                     case 0:
  426.                         retcode=1;
  427.                     case 1:
  428.                         done=1;
  429.                         break;
  430.                     default:
  431.                         break;
  432.                     }
  433.                 break;
  434.             default:
  435.                 break;
  436.             }
  437.         ReplyMsg((struct Message *)msg);    /* tell Intuition we're done with msg, thanx */
  438.         }
  439.     SetWindowTitles(win,(UBYTE *)-1,NULL);
  440.     ClearMenuStrip(win);                        /* remove menu strip */
  441.     CloseWindow(win);
  442.     pic_win.TopEdge-=barheight+1;
  443.     return(retcode);
  444. }
  445.  
  446. /***************************************************************************/
  447.  
  448. int display_image_screen(file)
  449. char *file;
  450.  
  451. {
  452.     int done=0,retcode=0,cnt,colors,r,g,b;
  453.     struct IntuiMessage *msg;
  454.     struct Screen *screen;
  455.     struct Window *win;
  456.     struct ExecBase *SysBase=*(struct ExecBase **)4;
  457.  
  458.                                                     /* now set window width & height */
  459.     tags[1].ti_Data=bmh.w;
  460.     tags[2].ti_Data=bmh.h+barheight;
  461.     tags[3].ti_Data=loadimg.bitmap1->Depth;
  462.     newscreen.Width = bmh.w;
  463.     newscreen.Height = bmh.h+barheight;
  464.     newscreen.Depth = loadimg.bitmap1->Depth;
  465.     newscreen.ViewModes = loadimg.modes;
  466.     if (!(screen=(struct Screen *)OpenScreen((struct NewScreen *)&newscreen)))
  467.         {
  468.         DisplayBeep(NULL);
  469.         return(1);                                /* if can't open screen, go back to WB window */
  470.         }
  471.     pic_win2.Width=bmh.w;
  472.     pic_win2.Height=bmh.h+barheight;
  473.     pic_win2.Screen = screen;
  474.     pic_win2.BitMap=loadimg.bitmap1;        /* ptr to refresh bitmap */
  475.     if (!(win=OpenWindow(&pic_win2)))
  476.         {
  477.         CloseScreen(screen);
  478.         DisplayBeep(NULL);
  479.         return(1);                                /* unable to open window */
  480.         }
  481.     colors=1<<loadimg.bitmap1->Depth;
  482.     if (IntuitionBase->LibNode.lib_Version >= 39)    /* if OS 3.0 or above */
  483.         {
  484.         for (cnt=0; cnt < colors; cnt++)
  485.             {
  486.             r=(color[cnt]&0x00ff0000)<<8;
  487.             g=(color[cnt]&0x0000ff00)<<16;
  488.             b=(color[cnt]&0x000000ff)<<24;
  489.             SetRGB32(&screen->ViewPort,cnt,r,g,b);
  490.             }
  491.         }
  492.     else
  493.         {
  494.         for (cnt=0; cnt < colors; cnt++)
  495.             {
  496.             r=(color[cnt]>>20)&0xf;
  497.             g=(color[cnt]>>12)&0xf;
  498.             b=(color[cnt]>>4)&0xf;
  499.             SetRGB4(&screen->ViewPort,cnt,r,g,b);
  500.             }
  501.         }
  502.     SetWindowTitles(win,screen_title,(UBYTE *)-1);
  503.     item1a_it.IText=wb_text;
  504.     SetMenuStrip(win,&menu1);                /* tack on the menu */
  505.     while (!done)
  506.         {
  507.         WaitPort(win->UserPort);            /* wait for Intuition message */
  508.         msg=(struct IntuiMessage *)GetMsg(win->UserPort);
  509.         switch (msg->Class)
  510.             {
  511.             case CLOSEWINDOW:
  512.                 done=1;
  513.                 break;
  514.             case MENUPICK:
  515.                 switch (ITEMNUM(msg->Code))
  516.                     {
  517.                     case 0:
  518.                         retcode=1;
  519.                     case 1:
  520.                         done=1;
  521.                         break;
  522.                     default:
  523.                         break;
  524.                     }
  525.                 break;
  526.             default:
  527.                 break;
  528.             }
  529.         ReplyMsg((struct Message *)msg);    /* tell Intuition we're done with msg, thanx */
  530.         }
  531.     SetWindowTitles(win,(UBYTE *)-1,NULL);
  532.     ClearMenuStrip(win);                        /* remove menu strip */
  533.     CloseWindow(win);
  534.     CloseScreen(screen);
  535.     return(retcode);
  536. }
  537.